/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.dp1.pucp.Simulacion.Controlador;

import CharliesCookies.MainMenuGUI;
import com.dp1.pucp.Administracion.DAO.RRHHDAO;
import com.dp1.pucp.Logistica.DAO.TipoProductoDAO;
import com.dp1.pucp.Modelo.Algoritmos.EmpleadoAlgoritmo;
import com.dp1.pucp.Modelo.Algoritmos.Galleta;
import com.dp1.pucp.Modelo.Algoritmos.MaquinaA;
import com.dp1.pucp.Modelo.Algoritmos.Recocido;
import com.dp1.pucp.Modelo.Algoritmos.TipoGalleta;
import com.dp1.pucp.Modelo.Algoritmos.Maquinas;
import com.dp1.pucp.Modelo.Algoritmos.Solucion;
import com.dp1.pucp.Modelo.Clases.Cliente;
import com.dp1.pucp.Modelo.Clases.Demanda;
import com.dp1.pucp.Modelo.Clases.Demandaxpedidoproducto;
import com.dp1.pucp.Modelo.Clases.Empleado;
import com.dp1.pucp.Modelo.Clases.Empleadoxmaquinasimulacion;

import com.dp1.pucp.Modelo.Clases.Historico;
import com.dp1.pucp.Modelo.Clases.Lineapedidoproducto;

import com.dp1.pucp.Modelo.Clases.Maquina;
import com.dp1.pucp.Modelo.Clases.Parametrosalgoritmo;
import com.dp1.pucp.Modelo.Clases.Pedidoproducto;
import com.dp1.pucp.Modelo.Clases.Productointermedio;
import com.dp1.pucp.Modelo.Clases.Productosimulacion;
import com.dp1.pucp.Modelo.Clases.Productoxmaquina;
import com.dp1.pucp.Modelo.Clases.RecetaPfPi;
import com.dp1.pucp.Modelo.Clases.Simulacion;
import com.dp1.pucp.Modelo.Clases.Superhombre;
import com.dp1.pucp.Modelo.Clases.Tipoproducto;
import com.dp1.pucp.Produccion.Controlador.AsignarSimulacionControlador;
import com.dp1.pucp.Produccion.DAO.ProduccionDAO;
import com.dp1.pucp.Produccion.Vista.AsignarSimulacionGUI;

import com.dp1.pucp.Simulacion.DAO.SimulacionDAO;
import com.dp1.pucp.Simulacion.VIsta.AsignacionEmpleadosGUI;
import com.dp1.pucp.Simulacion.VIsta.AsignacionMaquinasGUI;
import com.dp1.pucp.Simulacion.VIsta.ConsultaPedidosGUI2;
import com.dp1.pucp.Simulacion.VIsta.MantSimulacionGUI2;
import com.dp1.pucp.Simulacion.VIsta.ResSimulacionGUI;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumn;

/**
 *
 * @author Rodrigo
 */
public class SimulacionControlador {

    private MantSimulacionGUI2 simulacionView;
    private ConsultaPedidosGUI2 consultaPedidosView;
    private SimulacionDAO s;
    private RRHHDAO r;
    private ArrayList<Empleado> arregloEmpleadosTotal;
    private MainMenuGUI vistaPrincipal;
    private ArrayList<EmpleadoAlgoritmo> arregloEmpleadosAlgoritmo;
    private ArrayList<EmpleadoAlgoritmo> arregloEmpleadosTurno1;
    private ArrayList<EmpleadoAlgoritmo> arregloEmpleadosTurno2;
    private ArrayList<EmpleadoAlgoritmo> arregloEmpleadosTurno3;
    private ArrayList<Maquina> arregloMaquinas;
    //arreglos de simulaciones guardados en memoria
    private ArrayList<Simulacion> arregloSimulacionesTurno1;
    private ArrayList<Simulacion> arregloSimulacionesTurno2;
    private ArrayList<Simulacion> arregloSimulacionesTurno3;
    private ArrayList<Solucion> arregloSolucionesTurno1;
    private ArrayList<Solucion> arregloSolucionesTurno2;
    private ArrayList<Solucion> arregloSolucionesTurno3;
    private ArrayList<Pedidoproducto> listaPedidoProducto;
    private AsignacionEmpleadosControlador asignacionEmpleadosControlador;
    private AsignacionMaquinasControlador asignacionMaquinasControlador;
    private int vieneDeAtencionPedido = 0; //0=SI 1=NO
    private int seAsignoSimulacionDemanda1 = 0;
    private int seAsignoSimulacionDemanda2 = 0;
    private int seAsignoSimulacionDemanda3 = 0;
    private Demanda demanda1;
    private Demanda demanda2;
    private Demanda demanda3;

    public SimulacionControlador(SimulacionDAO dao, RRHHDAO rdao, MantSimulacionGUI2 simulacionView, ConsultaPedidosGUI2 consultaPedidosView, MainMenuGUI vistaPrincipal) {

        this.s = dao;
        this.simulacionView = simulacionView;
        this.consultaPedidosView = consultaPedidosView;
        this.r = rdao;
        this.vistaPrincipal = vistaPrincipal;
        simulacionView.listarTurno();
        simulacionView.limpiarDatos();
        simulacionView.addLimpiarListener(new limpiarListener());
        simulacionView.addEmpleadosListener(new asignarEmpleadosListener());
        simulacionView.addMaquinasListener(new asignarMaquinasListener());
        simulacionView.addSimularListener(new simularListener());
        consultaPedidosView.addActualizarListener(new actualizarListener());
        consultaPedidosView.addAsignarTurno1Listener(new AsignarTurno1Listener());
        consultaPedidosView.addAsignarTurno2Listener(new AsignarTurno2Listener());
        consultaPedidosView.addAsignarTurno3Listener(new AsignarTurno3Listener());
        consultaPedidosView.addGuardarListener(new guardarListener());
        consultaPedidosView.addSimularTurno1Listener(new simularTurno1Listener());
        consultaPedidosView.addSimularTurno2Listener(new simularTurno2Listener());
        consultaPedidosView.addSimularTurno3Listener(new simularTurno3Listener());
        simulacionView.addVolverListener(new volverListener());

        this.llenarEmpleadosTotal();
        this.llenarMaquinas();
        this.llenarEmpleadosA();
        // this.leerhistoricos();//comentar estoMIRAAAAAAAAAAA
        this.distribuirTurnos();
        this.llenarPedidosProducto();//saca pedidoProducto de DAO
        resetArreglosSimulaciones();//reinicia los arreglos de simulaciones auxiliares
        resetDemandas();//reinicia los arreglos de demandas auxiliares
        ActualizarTablaPedidos(); //llena arreglos por primera vez
        leerHistoricos2(arregloEmpleadosTurno1);//probando
        leerHistoricos2(arregloEmpleadosTurno2);
        leerHistoricos2(arregloEmpleadosTurno3);



    }

    public ArrayList<EmpleadoAlgoritmo> getEmpleadosxTurno(int turno) {
        ArrayList<EmpleadoAlgoritmo> res = new ArrayList<EmpleadoAlgoritmo>();
        switch (turno) {
            case 1:
                res = arregloEmpleadosTurno1;
                break;
            case 2:
                res = arregloEmpleadosTurno2;
                break;
            case 3:
                res = arregloEmpleadosTurno3;
                break;
        }
        return res;
    }

    private void resetDemandas() {
        demanda1 = new Demanda();
        demanda2 = new Demanda();
        demanda3 = new Demanda();
    }

    private void resetArreglosSimulaciones() {

        arregloSimulacionesTurno1 = new ArrayList<Simulacion>();
        arregloSimulacionesTurno2 = new ArrayList<Simulacion>();
        arregloSimulacionesTurno3 = new ArrayList<Simulacion>();
        arregloSolucionesTurno1 = new ArrayList<Solucion>();
        arregloSolucionesTurno2 = new ArrayList<Solucion>();
        arregloSolucionesTurno3 = new ArrayList<Solucion>();
        resetDemandas();

    }

    public int getTurnoSimulacion() {
        return (simulacionView.getTurno() + 1);
    }

    private SimulacionControlador getControlador() {
        return this;
    }

    private void llenarPedidosProducto() {
        listaPedidoProducto = s.getPedidosProductoxEstado(1);
    }

    public void ActualizarTablaPedidos() {
        limpiarDatosPedidos();
        llenarPedidosProducto();
        llenaGrillaPedidos(listaPedidoProducto);
    }

    public void llenaGrillaPedidos(ArrayList<Pedidoproducto> lista) {
        if (lista != null) {

            ((DefaultTableModel) consultaPedidosView.getTabla().getModel()).setRowCount(0);
            for (int i = 0; i < lista.size(); i++) {
                ((DefaultTableModel) consultaPedidosView.getTabla().getModel()).setRowCount(consultaPedidosView.getTabla().getRowCount() + 1);
                consultaPedidosView.getTabla().setValueAt(lista.get(i).getIdpedidoproducto(), i, 0);
                consultaPedidosView.getTabla().setValueAt(lista.get(i).getFechaRegistro(), i, 1);
                if (lista.get(i).getEstado() == 0) {
                    consultaPedidosView.getTabla().setValueAt("Cancelado", i, 2);
                }
                if (lista.get(i).getEstado() == 1) {
                    consultaPedidosView.getTabla().setValueAt("Registrado", i, 2);
                }
                if (lista.get(i).getEstado() == 2) {
                    consultaPedidosView.getTabla().setValueAt("Compra", i, 2);
                }
                if (lista.get(i).getEstado() == 3) {
                    consultaPedidosView.getTabla().setValueAt("Proceso", i, 2);
                }
                if (lista.get(i).getEstado() == 4) {
                    consultaPedidosView.getTabla().setValueAt("Finalizado", i, 2);
                }
                if (lista.get(i).getEstado() == 5) {
                    consultaPedidosView.getTabla().setValueAt("Entregado", i, 2);
                }
//                Cliente cliente = s.getClienteId(lista.get(i).getCliente().getIdcliente());
//                consultaPedidosView.getTabla().setValueAt(cliente.getRazonsocial(),i,2);
                // consultaPedidosView.getTabla().setValueAt(lista.get(i).getTotal(),i,3);
            }
        }
    }

    public void limpiarDatosPedidos() {
        ((DefaultTableModel) consultaPedidosView.getTabla().getModel()).setRowCount(0);
    }

    class volverListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            simulacionView.setVisible(false);
            vieneDeAtencionPedido = 1;
            consultaPedidosView.setVisible(true);
            vistaPrincipal.setCurrentPanel(consultaPedidosView);

        }
    }

    class simularListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            s = new SimulacionDAO();
            Parametrosalgoritmo param = s.getParametros();
            if (param.getIdparametrosalgoritmo()==0){
                simulacionView.mostrarError("Debe registrar parametros para el algoritmo");
                return;
            }
            Solucion sol = simulacion2(simulacionView.getGalletaSoda(), simulacionView.getGalletaRellena(), simulacionView.getGalletasDecorada(), simulacionView.getTurno() + 1, param.getIteracionesgrasp(), param.getFGrasp(), param.getTemperaturaInicial(), param.getTemperaturaFinal(), param.getFactorEnfriamiento());
            if (sol.calcProd() > 0) {

                ResSimulacionGUI gui = new ResSimulacionGUI(simulacionView.getPadre(), true);
                ResultadoSimulacionControlador controlador = new ResultadoSimulacionControlador(gui, sol, simulacionView.getTurno() + 1, getControlador());
                gui.setTitle("Resultado de Simulacion");
                gui.setVisible(true);
                Date date = new Date();
                Date date2 = new Date(date.getTime());

                if (vieneDeAtencionPedido == 1) {
                    Simulacion simu = convertSimulacion(sol, param, date2);
                    if (simulacionView.getTurno() == 0) {
                        arregloSimulacionesTurno1.add(simu);
                        arregloSolucionesTurno1.add(sol);
                    }
                    if (simulacionView.getTurno() == 1) {
                        arregloSimulacionesTurno2.add(simu);
                        arregloSolucionesTurno2.add(sol);
                    }
                    if (simulacionView.getTurno() == 2) {
                        arregloSimulacionesTurno3.add(simu);
                        arregloSolucionesTurno3.add(sol);
                    }
                }
                if (vieneDeAtencionPedido == 0) {
                    convertSimulacion(sol, param, date2);
                }

            } else {
                simulacionView.mostrarAviso("Hay suficiente stock en almacen para satisfacer el pedido");
            }


        }
    }

    class asignarMaquinasListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            AsignacionMaquinasGUI gui = new AsignacionMaquinasGUI(simulacionView.getPadre(), true);
            gui.setTitle("Asignacion de Maquinas");

            AsignacionMaquinasControlador controlador = new AsignacionMaquinasControlador(s, gui, simulacionView, arregloMaquinas);

            gui.setLocationRelativeTo(null);//Metodo para que la ventana sea MODAL
            gui.setVisible(true);
        }
    }

    class asignarEmpleadosListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            AsignacionEmpleadosGUI gui = new AsignacionEmpleadosGUI(simulacionView.getPadre(), true);
            leerHistoricos2(arregloEmpleadosTurno1);
            leerHistoricos2(arregloEmpleadosTurno2);
            leerHistoricos2(arregloEmpleadosTurno3);
            gui.setTitle("Asignacion de Empleados");
            AsignacionEmpleadosControlador controlador = new AsignacionEmpleadosControlador(s, gui, getControlador(), arregloEmpleadosTotal, arregloEmpleadosTurno1, arregloEmpleadosTurno2, arregloEmpleadosTurno3, getTurnoSimulacion());
            gui.setLocationRelativeTo(null);//Metodo para que la ventana sea MODAL
            gui.setVisible(true);
        }
    }

    class selTurnoListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            //InsumoProductoView.LimpiarDatos();
        }
    }

    //INICIO PANTALLA CONSULTAPEDIDOSGUI
    public void resetTablaDemandas() {
        ((DefaultTableModel) consultaPedidosView.getTabla1().getModel()).setRowCount(0);
        ((DefaultTableModel) consultaPedidosView.getTabla2().getModel()).setRowCount(0);
        ((DefaultTableModel) consultaPedidosView.getTabla3().getModel()).setRowCount(0);
    }

    public int estaEnArreglo(int numero, int[] arreglo) {
        int val = 0;
        for (int i = 0; i < arreglo.length; i++) {
            if (numero == arreglo[i]) {
                val = 1;
            }
        }
        return val;
    }

    class actualizarListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            resetArreglosSimulaciones();//al momento de actualizar las cantidades demandadas ya no hay simulaciones 
            //para asignar
            //aqui se revisan los pedidosSeleccionados
            int[] indices = consultaPedidosView.getTabla().getSelectedRows();//indice de arrelos seleccionados
            if (indices.length>0){
            System.out.println("RESULTADO ES :" +indices.length);
            ArrayList<Pedidoproducto> pedidosSeleccionados = new ArrayList<Pedidoproducto>();
            for (int i = 0; i < listaPedidoProducto.size(); i++) {
                if (estaEnArreglo(i, indices) == 1) {
                    Pedidoproducto pedido = listaPedidoProducto.get(i);
                    pedidosSeleccionados.add(pedido);//arreglo de pedidosSeleccionados                  
                }
            }
            demanda1 = new Demanda();
            demanda2 = new Demanda();
            demanda3 = new Demanda();
            calculademanda(pedidosSeleccionados, demanda1, demanda2, demanda3);
            consultaPedidosView.llenarTurnos(demanda1, demanda2, demanda3);
            consultaPedidosView.mostrarAviso("Se actualizaron las cantidades demandadas");
        } else {
                consultaPedidosView.mostrarError("Debe seleccionar mínimo un pedido");
            }
        }
    }

    class guardarListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            int bandera = 0;
            ProduccionDAO dao = new ProduccionDAO();
            SimulacionDAO sdao = new SimulacionDAO();
            TipoProductoDAO pdao = new TipoProductoDAO();
            if ((demanda1.getSimulacion() != null) && (demanda2.getSimulacion() != null) && (demanda3.getSimulacion() != null)) {
                //if ((seAsignoSimulacionDemanda1==1) && (seAsignoSimulacionDemanda2==1) && (seAsignoSimulacionDemanda3==1)){
                seleccionarsimulacion(demanda1, demanda1.getSimulacion());
                seleccionarsimulacion(demanda2, demanda2.getSimulacion());
                seleccionarsimulacion(demanda3, demanda3.getSimulacion());
                int[] indices = consultaPedidosView.getTabla().getSelectedRows();

                for (int i = 0; i < listaPedidoProducto.size(); i++) {

                    // listaPedidoProducto.get(i).setEstado(2);

                    // pdao.guardarPedidoProducto(listaPedidoProducto.get(i));

                    if (estaEnArreglo(i, indices) == 1) {
                        listaPedidoProducto.get(i).setEstado(2);
                        Demandaxpedidoproducto demxpe = new Demandaxpedidoproducto();
                        demxpe.setDemanda(demanda1);
                        demxpe.setPedidoproducto(listaPedidoProducto.get(i));
                        Demandaxpedidoproducto demxpe2 = new Demandaxpedidoproducto();
                        demxpe2.setDemanda(demanda2);
                        demxpe2.setPedidoproducto(listaPedidoProducto.get(i));
                        Demandaxpedidoproducto demxpe3 = new Demandaxpedidoproducto();
                        demxpe3.setDemanda(demanda3);
                        demxpe3.setPedidoproducto(listaPedidoProducto.get(i));
                        sdao.guardarDemandaxpedidoproducto(demxpe);
                        sdao.guardarDemandaxpedidoproducto(demxpe2);
                        sdao.guardarDemandaxpedidoproducto(demxpe3);
                        pdao.guardarPedidoProducto(listaPedidoProducto.get(i));
                    }

                }
                consultaPedidosView.mostrarAviso("Se guardaron las demandas");
                ActualizarTablaPedidos();
                resetTablaDemandas();
            } else {
                consultaPedidosView.mostrarError("No se guardaron las demandas");
            }
        }
    }

    class simularTurno1Listener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            int cant_soda;
            int cant_deco;
            int cant_relle;

            cant_soda = consultaPedidosView.getGalletaSodaTurno1();
            cant_deco = consultaPedidosView.getGalletaDecoradaTurno1();
            cant_relle = consultaPedidosView.getGalletaRellenaTurno1();
            simulacionView.setGalletas(cant_soda, cant_deco, cant_relle);
            simulacionView.setTurno(0);
            simulacionView.fijarComboBox();
            consultaPedidosView.setVisible(false);
            vieneDeAtencionPedido = 1;
            simulacionView.setVisible(true);
            vistaPrincipal.setCurrentPanel(simulacionView);
        }
    }

    class simularTurno2Listener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            int cant_soda;
            int cant_deco;
            int cant_relle;

            cant_soda = consultaPedidosView.getGalletaSodaTurno2();
            cant_deco = consultaPedidosView.getGalletaDecoradaTurno2();
            cant_relle = consultaPedidosView.getGalletaRellenaTurno2();
            simulacionView.setGalletas(cant_soda, cant_deco, cant_relle);
            simulacionView.setTurno(1);
            simulacionView.fijarComboBox();
            consultaPedidosView.setVisible(false);
            vieneDeAtencionPedido = 1;
            simulacionView.setVisible(true);
            vistaPrincipal.setCurrentPanel(simulacionView);

        }
    }

    class simularTurno3Listener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            int cant_soda;
            int cant_deco;
            int cant_relle;

            cant_soda = consultaPedidosView.getGalletaSodaTurno3();
            cant_deco = consultaPedidosView.getGalletaDecoradaTurno3();
            cant_relle = consultaPedidosView.getGalletaRellenaTurno3();
            simulacionView.setGalletas(cant_soda, cant_deco, cant_relle);
            simulacionView.setTurno(2);
            simulacionView.fijarComboBox();
            consultaPedidosView.setVisible(false);
            vieneDeAtencionPedido = 1;
            simulacionView.setVisible(true);
            vistaPrincipal.setCurrentPanel(simulacionView);

        }
    }

    class AsignarTurno1Listener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            //(if (demanda1.getSimulacion()!=null) {
            AsignarSimulacionGUI gui = new AsignarSimulacionGUI(consultaPedidosView.getPadre(), true);
            System.out.println("TAMAÑO ARREGLO SOLUCION: " + arregloSolucionesTurno3.size());
            AsignarSimulacionControlador controlador = new AsignarSimulacionControlador(gui, arregloSimulacionesTurno1, demanda1, seAsignoSimulacionDemanda1, arregloSolucionesTurno1);
            gui.setVisible(true);
            //}     
            //else {
            //    consultaPedidosView.mostrarError("Ya se asigno una simulacion");
            //}
        }
    }

    class AsignarTurno2Listener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            //if (demanda2.getSimulacion()!=null){
            AsignarSimulacionGUI gui = new AsignarSimulacionGUI(consultaPedidosView.getPadre(), true);
            AsignarSimulacionControlador controlador = new AsignarSimulacionControlador(gui, arregloSimulacionesTurno2, demanda2, seAsignoSimulacionDemanda2, arregloSolucionesTurno2);
            gui.setVisible(true);
            //}
            //else {
            //    consultaPedidosView.mostrarError("Ya se asigno una simulacion");
            //}
        }
    }

    class AsignarTurno3Listener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            //if (demanda3.getSimulacion()!=null) {
            AsignarSimulacionGUI gui = new AsignarSimulacionGUI(consultaPedidosView.getPadre(), true);
            AsignarSimulacionControlador controlador = new AsignarSimulacionControlador(gui, arregloSimulacionesTurno3, demanda3, seAsignoSimulacionDemanda3, arregloSolucionesTurno3);
            System.out.println("TAMAÑO ARREGLO SOLUCION: " + arregloSolucionesTurno3.size());
            gui.setVisible(true);
            //}
            //else {
            //    consultaPedidosView.mostrarError("Ya se asigno una simulacion");
            //}
        }
    }

    //FIN PANTALLA CONSULTAPEDIDOSGUI
    class limpiarListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            //InsumoProductoView.LimpiarDatos();
            simulacionView.limpiarDatos();
        }
    }

    private void llenarEmpleadosTotal() {
        //Se llena el arreglo de empleados para obtener su nombre y enlazarlo con su rendimiento
        //enlazando con los IDs de cada uno, esto se realiza para llenar las tablas de empleados
        //que estan clasificadas por turno
        int estadoEmpleado = 1;//Poner estado activo
        RRHHDAO rh = new RRHHDAO();
        //this.arregloEmpleadosTotal=rh.listarEmpleado();
        this.arregloEmpleadosTotal = rh.listarOperarios();
    }

    private void llenarEmpleadosA() {
        this.arregloEmpleadosAlgoritmo = new ArrayList();
        for (int i = 0; i < this.arregloEmpleadosTotal.size(); i++) {
            if (arregloEmpleadosTotal.get(i).getEstado() == 1) {
                EmpleadoAlgoritmo emp = new EmpleadoAlgoritmo(arregloEmpleadosTotal.get(i));
                this.arregloEmpleadosAlgoritmo.add(emp);
            }
        }
    }

    private void llenarMaquinas() {
        //Se llena el arreglo de maquinas para obtener sus datos y que sean utilizados en la ventana de 
        //maquinaria y elegidas para la simulacion(revisar wall-e)
        this.arregloMaquinas = s.listarMaquinas();
        //this.arregloMaquinas=s.listarMaquinas();
    }

    public void leerHistoricos2(ArrayList<EmpleadoAlgoritmo> empleados) {
        s = new SimulacionDAO();
        for (int i = 0; i < empleados.size(); i++) {
            int bandera = 0;
            EmpleadoAlgoritmo emp = empleados.get(i);
            ArrayList<Historico> historicoemp = s.historiaEmpleado(emp.getIdempleado(), emp.getTurno());//por cada operario obtendre su historico
            int[] produccion = new int[4];
            int[] mermas = new int[4];
            int[] contadores = new int[4];//contara los hisoricos para cada tipo de maquina
            int sumaprod = 0;
            int sumamerm = 0;
            Superhombre superhombre = s.getSuperHombre(emp.getIdempleado());
            if (superhombre.getIdsuperhombre() != 0) {
                if (superhombre.getEstado() == 1) {
                    produccion[0] = superhombre.getProduccionHorneado();
                    produccion[1] = superhombre.getProduccionDecorado();
                    produccion[2] = superhombre.getProduccionRellenado();
                    produccion[3] = superhombre.getProduccionEmpaquetado();
                    mermas[0] = superhombre.getMermaHorneado();
                    mermas[1] = superhombre.getMermaDecorado();
                    mermas[2] = superhombre.getMermaRellenado();
                    mermas[3] = superhombre.getMermaEmpaquetado();
                    bandera = 1;
                }
                bandera = 0;
            }
            if (bandera == 0) {
                for (int j = 0; j < historicoemp.size(); j++) {
                    Historico historico = historicoemp.get(j);
                    // if(emp.getTurno()==historico.getTurno()){
                    switch (historico.getTipomaquina().getIdtipomaquina()) {//por cada historico del empleado calculare su promedio de produ y merm
                        case 1:  //observare a que tipo de maquina corresponde esa produccion y merma
                            sumaprod = produccion[0] * contadores[0];
                            sumamerm = mermas[0] * contadores[0];
                            contadores[0] = contadores[0] + 1;
                            produccion[0] = (sumaprod + historico.getProduccion()) / contadores[0];//saco el promedio de produccion
                            mermas[0] = (sumamerm + historico.getMerma()) / contadores[0];

                            break;
                        case 2:
                            sumaprod = produccion[1] * contadores[1];
                            sumamerm = mermas[1] * contadores[1];
                            contadores[1] = contadores[1] + 1;
                            produccion[1] = (sumaprod + historico.getProduccion()) / contadores[1];
                            mermas[1] = (sumamerm + historico.getMerma()) / contadores[1];
                            break;
                        case 3:
                            sumaprod = produccion[2] * contadores[2];
                            sumamerm = mermas[2] * contadores[2];

                            contadores[2] = contadores[2] + 1;
                            produccion[2] = (produccion[2] + historico.getProduccion()) / contadores[2];
                            mermas[2] = (mermas[2] + historico.getMerma()) / contadores[2];
                            break;
                        case 4:
                            sumaprod = produccion[3] * contadores[3];
                            sumamerm = mermas[3] * contadores[3];
                            contadores[3] = contadores[3] + 1;
                            produccion[3] = (produccion[3] + historico.getProduccion()) / contadores[3];
                            mermas[3] = (mermas[3] + historico.getMerma()) / contadores[3];

                    }
                }
            }
            //}
            emp.setProduccion(produccion);
            emp.setMermas(mermas);
            emp.calcularCap(produccion, mermas);
            // this.arregloEmpleadosAlgoritmo.add(emp);

        }
    }

    private void leerhistoricos() {// cambiar esto a que reciba el arreglo por turno y cambiar el historia empleado para que lo filtre por turno tmb

        //arregloEmpleadosTotal = s.listarOperarios();       //lista todos los operarios
        s = new SimulacionDAO();
        //this.arregloEmpleadosAlgoritmo= new ArrayList<EmpleadoAlgoritmo>();
        for (int i = 0; i < arregloEmpleadosTotal.size(); i++) {
            int bandera = 0;
            // EmpleadoAlgoritmo emp = new EmpleadoAlgoritmo(arregloEmpleadosTotal.get(i));
            EmpleadoAlgoritmo emp = this.arregloEmpleadosAlgoritmo.get(i);
            ArrayList<Historico> historicoemp = s.historiaEmpleado(emp.getIdempleado(), emp.getTurno());//por cada operario obtendre su historico
            int[] produccion = new int[4];
            int[] mermas = new int[4];
            int[] contadores = new int[4];//contara los hisoricos para cada tipo de maquina
            int sumaprod = 0;
            int sumamerm = 0;
            Superhombre superhombre = s.getSuperHombre(emp.getIdempleado());
            if (superhombre.getIdsuperhombre() != 0) {
                if (superhombre.getEstado() == 1) {
                    produccion[0] = superhombre.getProduccionHorneado();
                    produccion[1] = superhombre.getProduccionDecorado();
                    produccion[2] = superhombre.getProduccionRellenado();
                    produccion[3] = superhombre.getProduccionEmpaquetado();
                    mermas[0] = superhombre.getMermaHorneado();
                    mermas[1] = superhombre.getMermaDecorado();
                    mermas[2] = superhombre.getMermaRellenado();
                    mermas[3] = superhombre.getMermaEmpaquetado();
                    bandera = 1;
                }
                bandera = 0;
            }
            if (bandera == 0) {
                for (int j = 0; j < historicoemp.size(); j++) {
                    Historico historico = historicoemp.get(j);

                    switch (historico.getTipomaquina().getIdtipomaquina()) {//por cada historico del empleado calculare su promedio de produ y merm
                        case 1:  //observare a que tipo de maquina corresponde esa produccion y merma
                            sumaprod = produccion[0] * contadores[0];
                            sumamerm = mermas[0] * contadores[0];
                            contadores[0] = contadores[0] + 1;
                            produccion[0] = (sumaprod + historico.getProduccion()) / contadores[0];//saco el promedio de produccion
                            mermas[0] = (sumamerm + historico.getMerma()) / contadores[0];

                            break;
                        case 2:
                            sumaprod = produccion[1] * contadores[1];
                            sumamerm = mermas[1] * contadores[1];
                            contadores[1] = contadores[1] + 1;
                            produccion[1] = (sumaprod + historico.getProduccion()) / contadores[1];
                            mermas[1] = (sumamerm + historico.getMerma()) / contadores[1];
                            break;
                        case 3:
                            sumaprod = produccion[2] * contadores[2];
                            sumamerm = mermas[2] * contadores[2];

                            contadores[2] = contadores[2] + 1;
                            produccion[2] = (produccion[2] + historico.getProduccion()) / contadores[2];
                            mermas[2] = (mermas[2] + historico.getMerma()) / contadores[2];
                            break;
                        case 4:
                            sumaprod = produccion[3] * contadores[3];
                            sumamerm = mermas[3] * contadores[3];
                            contadores[3] = contadores[3] + 1;
                            produccion[3] = (produccion[3] + historico.getProduccion()) / contadores[3];
                            mermas[3] = (mermas[3] + historico.getMerma()) / contadores[3];

                    }

                }
            }//fin de if bandera
            emp.setProduccion(produccion);
            emp.setMermas(mermas);
            emp.calcularCap(produccion, mermas);
            //this.arregloEmpleadosAlgoritmo.add(emp);
        }
    }

    public void distribuirTurnos() {
        this.arregloEmpleadosTurno1 = new ArrayList<EmpleadoAlgoritmo>();
        this.arregloEmpleadosTurno2 = new ArrayList<EmpleadoAlgoritmo>();
        this.arregloEmpleadosTurno3 = new ArrayList<EmpleadoAlgoritmo>();
        for (int i = 0; i < arregloEmpleadosAlgoritmo.size(); i++) {
            EmpleadoAlgoritmo emp = arregloEmpleadosAlgoritmo.get(i);

            switch (arregloEmpleadosAlgoritmo.get(i).getTurno()) {
                case 1:
                    arregloEmpleadosTurno1.add(copiarEmp(emp));
                    break;
                case 2:
                    arregloEmpleadosTurno2.add(copiarEmp(emp));
                    break;
                case 3:
                    arregloEmpleadosTurno3.add(copiarEmp(emp));
            }
        }

    }

    public void redistribuirTurno(EmpleadoAlgoritmo emp, int posicion, int turnonuevo) {//recibira la clase empleado de la tabla 
        switch (emp.getTurno()) {                                                 //tambien la posicion de la tabla que es la posicion del arreglo en la que se encontro
            case 1:
                arregloEmpleadosTurno1.remove(posicion);                    //y el turno nuevo
                break;
            case 2:
                arregloEmpleadosTurno2.remove(posicion);
                break;
            case 3:
                arregloEmpleadosTurno3.remove(posicion);

        }
        EmpleadoAlgoritmo nuevo = copiarEmp(emp);
        nuevo.setTurno(turnonuevo);
        switch (turnonuevo) {
            case 1:
                arregloEmpleadosTurno1.add(nuevo);
                break;
            case 2:
                arregloEmpleadosTurno2.add(nuevo);
                break;
            case 3:
                arregloEmpleadosTurno3.add(nuevo);

        }
    }

    public Solucion simulacion2(int gallnormal, int gallrell, int galldec, int turno, int iteragrasp, double alfa, double tini, double ifin, double ratio) {
        Recocido recocido = new Recocido();
        TipoProductoDAO tdao = new TipoProductoDAO();//TIPOPRODUCTO Y RECETA necesario para sacar inv inicial(faltametodo)
        SimulacionDAO sdao = new SimulacionDAO();//procecosx maquina(incompleto), obtener precio, invinicial(incompleto)
        Solucion sol = new Solucion();
        ArrayList<Galleta> galletas = new ArrayList();

        Tipoproducto galnormal = tdao.buscarTipoProducto(1);//galleta
        ArrayList<Productointermedio> listainvnormal = sdao.getInvInicial(1);//list pra inv inicial
        ArrayList<RecetaPfPi> recetanormal = sdao.getIdTipoProductoIntermedio(1);//.listarRecetaPi(1);//receta
        int[] recetan = new int[recetanormal.size()];
        for (int i = 0; i < recetanormal.size(); i++) {
            recetan[i] = recetanormal.get(i).getTipoproductoByIdtipoproductoPi().getIdtipoproducto();//arreglo con ids de los prod int de la receta

        }

        double precionormal = (double) sdao.getPrecio(1);//precio

        int[] inv_ininormal = new int[recetanormal.size()];
        for (int i = 0; i < recetanormal.size(); i++) {
            Tipoproducto intermedio = recetanormal.get(i).getTipoproductoByIdtipoproductoPi();//saco el prodintermedio de la galleta
            inv_ininormal[i] = Math.round((listainvnormal.get(i).getVolumen() / intermedio.getFactorVol()) / 30); //calculo el inv inicial   
        }
        ArrayList<Productoxmaquina> procesosnormal = sdao.procesoxProd(1);
        ArrayList<Integer> procesosn = new ArrayList();
        ArrayList<Float> preciosn = new ArrayList();
        ArrayList<Float> costosn = new ArrayList();

        for (int i = 0; i < procesosnormal.size(); i++) {
            Productoxmaquina prod = procesosnormal.get(i);
            procesosn.add(prod.getTipomaquina().getIdtipomaquina());
            preciosn.add(prod.getPorcentajePrecio());
            costosn.add(prod.getPorcentajeCosto());
        }
        TipoGalleta tipo1 = new TipoGalleta(galnormal.getIdtipoproducto(), procesosn, preciosn, costosn, precionormal, 0.1);
        Galleta galle_normal = new Galleta(tipo1.getIdTipo(), tipo1, gallnormal);
        galle_normal.setNumGalletasPedidas(gallnormal);
        galle_normal.setInv_ini_proc(inv_ininormal);
        galletas.add(galle_normal);
        //crea galleta, añade

        Tipoproducto galdecorada = tdao.buscarTipoProducto(2);
        ArrayList<RecetaPfPi> recetadecorada = sdao.getIdTipoProductoIntermedio(2);
        int[] recetad = new int[recetadecorada.size()];
        for (int i = 0; i < recetadecorada.size(); i++) {
            recetad[i] = recetadecorada.get(i).getTipoproductoByIdtipoproductoPi().getIdtipoproducto();//arreglo con ids de los prod int de la receta
        }
        double preciodecorada = (double) sdao.getPrecio(2);
        ArrayList<Productointermedio> listaintdec = sdao.getInvInicial(2);
        int[] inv_inidec = new int[recetadecorada.size()];
        for (int i = 0; i < recetadecorada.size(); i++) {
            Tipoproducto intermedio = recetadecorada.get(i).getTipoproductoByIdtipoproductoPi();
            float a = intermedio.getFactorVol();
            float b = listaintdec.get(i).getVolumen();
            inv_inidec[i] = Math.round((listaintdec.get(i).getVolumen() / intermedio.getFactorVol()) / 30);
        }
        ArrayList<Productoxmaquina> procesosdec = sdao.procesoxProd(2);
        ArrayList<Integer> procesosd = new ArrayList();
        ArrayList<Float> preciosd = new ArrayList();
        ArrayList<Float> costosd = new ArrayList();
        for (int i = 0; i < procesosdec.size(); i++) {
            Productoxmaquina prod = procesosdec.get(i);
            procesosd.add(prod.getTipomaquina().getIdtipomaquina());
            preciosd.add(prod.getPorcentajePrecio());
            costosd.add(prod.getPorcentajeCosto());
        }
        TipoGalleta tipo2 = new TipoGalleta(galdecorada.getIdtipoproducto(), procesosd, preciosd, costosd, preciodecorada, 0.1);
        Galleta gall_dec = new Galleta(tipo2.getIdTipo(), tipo2, galldec);
        gall_dec.setNumGalletasPedidas(galldec);
        gall_dec.setInv_ini_proc(inv_inidec);
        galletas.add(gall_dec);

        Tipoproducto galrellena = tdao.buscarTipoProducto(3);
        ArrayList<RecetaPfPi> recetarellena = sdao.getIdTipoProductoIntermedio(3);
        double preciorellena = (double) sdao.getPrecio(3);
        int[] recetar = new int[recetarellena.size()];
        for (int i = 0; i < recetarellena.size(); i++) {
            recetar[i] = recetarellena.get(i).getTipoproductoByIdtipoproductoPi().getIdtipoproducto();
        }
        ArrayList<Productointermedio> listarell = sdao.getInvInicial(3);
        int[] inv_inirell = new int[recetarellena.size()];
        for (int i = 0; i < listarell.size(); i++) {
            Tipoproducto intermedio = recetarellena.get(i).getTipoproductoByIdtipoproductoPi();
            inv_inirell[i] = Math.round((listarell.get(i).getVolumen() / intermedio.getFactorVol()) / 30);
        }
        ArrayList<Productoxmaquina> procesosrell = sdao.procesoxProd(3);
        ArrayList<Integer> procesosr = new ArrayList();
        ArrayList<Float> preciosr = new ArrayList();
        ArrayList<Float> costosr = new ArrayList();
        for (int i = 0; i < procesosrell.size(); i++) {
            Productoxmaquina prod = procesosrell.get(i);
            procesosr.add(prod.getTipomaquina().getIdtipomaquina());
            preciosr.add(prod.getPorcentajePrecio());
            costosr.add(prod.getPorcentajeCosto());
        }
        TipoGalleta tipo3 = new TipoGalleta(galrellena.getIdtipoproducto(), procesosr, preciosr, costosr, preciorellena, 0.1);
        Galleta gall_rell = new Galleta(tipo3.getIdTipo(), tipo3, gallrell);
        gall_rell.setNumGalletasPedidas(gallrell);
        gall_rell.setInv_ini_proc(inv_inirell);
        galletas.add(gall_rell);

        ArrayList<Maquina> auxMaquinas = filtrarMaquinas(this.arregloMaquinas);
        Maquinas maquinas = new Maquinas(auxMaquinas);

        //AGREGAR LOS CALCULOS DE POLITICAS DE STOCK
        for (int i = 0; i < galletas.size(); i++) {
            galletas.get(i).calcDemMaqPedido();
        }

        switch (turno) {
            case 1: //CAMBIAR A QUE DEPENDIENDO DEL TURNO HALLE SU HISTORICO, CAMBIO EN EL METODO NECESARIO
                //leerHistoricos2(arregloEmpleadosTurno1);
                sol = recocido.recocido_run2(arregloEmpleadosTurno1, galletas, maquinas, iteragrasp, alfa, tini, ifin, ratio, turno);

                return sol;
            case 2:    //leerHistoricos2(arregloEmpleadosTurno2);
                sol = recocido.recocido_run2(arregloEmpleadosTurno2, galletas, maquinas, iteragrasp, alfa, tini, ifin, ratio, turno);

                return sol;
            case 3://leerHistoricos2(arregloEmpleadosTurno3);
                sol = recocido.recocido_run2(arregloEmpleadosTurno3, galletas, maquinas, iteragrasp, alfa, tini, ifin, ratio, turno);

                return sol;

        }
        return null;

    }

    private ArrayList<Maquina> filtrarMaquinas(ArrayList<Maquina> maquinas) {
        //FUNCION FILTRA LAS MAQUINAS QUE ESTAN UTILIZABLES
        ArrayList<Maquina> arreglo = new ArrayList<Maquina>();
        for (int i = 0; i < maquinas.size(); i++) {
            arreglo.add(maquinas.get(i));
        }
        for (int i = 0; i < arreglo.size(); i++) {
            if (arreglo.get(i).getEstado() != 0) {
                arreglo.remove(i);
            }
        }
        return arreglo;
    }

    public Solucion simulacion(int gallnormal, int gallrell, int galldec, int turno, int iteragrasp, double alfa, double tini, double ifin, double ratio) {

        //las galletas, osea tipo de productos, los procesos(tipos de maquina) por galleta
        Recocido recocido = new Recocido();
        ArrayList<Galleta> galletas = new ArrayList();
        // if( gallnormal != 0){
        ArrayList<Integer> a = new ArrayList();//necesito sacar los precios y costos por proceso
        a.add(1);
        a.add(4);

        ArrayList<Float> porp1 = new ArrayList();
        porp1.add(0.6f);
        porp1.add(0.4f);

        ArrayList<Float> porc1 = new ArrayList();
        porc1.add(0.5f);
        porc1.add(0.5f);

        TipoGalleta normal = new TipoGalleta(1, a, porp1, porc1, 10, 1);

        int[] ini1 = {100, 100};//necesito sacar el inventario inicial de los productos intermedios por cada galleta

        Galleta galnormal = new Galleta(1, normal, gallnormal);
        galnormal.setInv_ini_proc(ini1);
        galletas.add(galnormal);
        // }
        // if(gallrell != 0){
        ArrayList<Integer> b = new ArrayList();
        b.add(1);
        b.add(3);
        b.add(4);

        ArrayList<Float> porp2 = new ArrayList();
        porp2.add(0.4f);
        porp2.add(0.4f);
        porp2.add(0.2f);

        ArrayList<Float> porc2 = new ArrayList();
        porc2.add(0.5f);
        porc2.add(0.3f);
        porc2.add(0.2f);

        TipoGalleta rellena = new TipoGalleta(3, b, porp2, porc2, 13, 1);
        int[] ini2 = {100, 100, 100};

        Galleta galrelle = new Galleta(3, rellena, gallrell);

        galrelle.setInv_ini_proc(ini2);
        galletas.add(galrelle);
        //   }  

        // if(galldec != 0){
        ArrayList<Integer> c = new ArrayList();
        c.add(1);
        c.add(2);
        c.add(4);

        ArrayList<Float> porp3 = new ArrayList();
        porp3.add(0.3f);
        porp3.add(0.5f);
        porp3.add(0.2f);

        ArrayList<Float> porc3 = new ArrayList();
        porc3.add(0.2f);
        porc3.add(0.4f);
        porc3.add(0.3f);

        TipoGalleta decorada = new TipoGalleta(2, c, porp3, porc3, 14, 9);
        int[] ini3 = {100, 100, 100};

        Galleta galdec = new Galleta(2, decorada, galldec);
        galdec.setInv_ini_proc(ini3);
        galletas.add(galdec);

        // }
        ArrayList<Maquina> auxMaquinas = filtrarMaquinas(this.arregloMaquinas);
        Maquinas maquinas = new Maquinas(auxMaquinas);
        //Maquinas maquinas = new Maquinas(this.arregloMaquinas);
        //AGREGAR LOS CALCULOS DE POLITICAS DE STOCK
        for (int i = 0; i < galletas.size(); i++) {
            galletas.get(i).calcDemMaqPedido();
        }
        switch (turno) {
            case 1: //CAMBIAR A QUE DEPENDIENDO DEL TURNO HALLE SU HISTORICO, CAMBIO EN EL METODO NECESARIO
                // leerHistoricos2(arregloEmpleadosTurno1);
                return recocido.recocido_run2(arregloEmpleadosTurno1, galletas, maquinas, iteragrasp, alfa, tini, ifin, ratio, turno);

            case 2:   // leerHistoricos2(arregloEmpleadosTurno2);
                return recocido.recocido_run2(arregloEmpleadosTurno2, galletas, maquinas, iteragrasp, alfa, tini, ifin, ratio, turno);
            case 3://leerHistoricos2(arregloEmpleadosTurno3);
                return recocido.recocido_run2(arregloEmpleadosTurno3, galletas, maquinas, iteragrasp, alfa, tini, ifin, ratio, turno);
        }
        return null;

    }

    public Empleado buscarEmpleado(int id) {

        for (int i = 0; i < arregloEmpleadosTotal.size(); i++) {
            if (arregloEmpleadosTotal.get(i).getIdempleado() == id) {
                return arregloEmpleadosTotal.get(i);
            }
        }

        return null;
    }

    public Simulacion convertSimulacion(Solucion solucion, Parametrosalgoritmo param, Date fecha) {

        Simulacion simulacion = new Simulacion(); // toy creando  el objeto de la tabla simulacion
        simulacion.setFechaHora(fecha);
        simulacion.setEstado(0);
        simulacion.setProduccion(solucion.calcProd() * 30);
        simulacion.setMerma(solucion.calcMerm() * 30);
        simulacion.setParametrosalgoritmo(param);
        simulacion.setCantnormal(solucion.getGalletas().get(0).getNumGalletasPedidas() * 30);
        simulacion.setCantdecorada(solucion.getGalletas().get(1).getNumGalletasPedidas() * 30);
        simulacion.setCantrellena(solucion.getGalletas().get(2).getNumGalletasPedidas() * 30);
        simulacion.setTurno(solucion.getTurno());

        Simulacion simu = s.guardarSimulacion2(simulacion);
        //GUARDAR SIMULACION

        EmpleadoAlgoritmo emp = new EmpleadoAlgoritmo();
        Empleado empleado = new Empleado();


        for (int i = 0; i < solucion.getAsignados().size(); i++) {


            Empleadoxmaquinasimulacion empmaqsi = new Empleadoxmaquinasimulacion();
            emp = solucion.getAsignados().get(i);
            empleado = buscarEmpleado(emp.getIdempleado());

            empmaqsi.setEmpleado(empleado);
            empmaqsi.setMaquina(buscarMaquina(emp.getMaquina()));
            empmaqsi.setTipoproducto(s.getTipoProductoId(emp.getGalletaAsignada().getTipogalleta().getIdTipo()));
            empmaqsi.setSimulacion(simu);
            s.guardarEmpxmaqsimu(empmaqsi);
            //GUARDAR CADA UNO
        }

        for (int i = 0; i < solucion.getGalletas().size(); i++) {
            Galleta gall = new Galleta();
            gall = solucion.getGalletas().get(i);
            ArrayList<RecetaPfPi> receta = s.getIdTipoProductoIntermedio(gall.getTipogalleta().getIdTipo());

            for (int j = 0; j < gall.getTipogalleta().getMaquinasProceso().size(); j++) {
                int merma = 0;
                Productosimulacion prosim = new Productosimulacion();
                prosim.setTipoproducto(receta.get(j).getTipoproductoByIdtipoproductoPi());

                prosim.setSimulacion(simu);

                // Productoxmaquina prodmaq = s.getProductoxMaquina(receta.get(i).getTipoproductoByIdtipoproductoPi().getIdtipoproducto());//podriacambiarlo a que no sea por bd
                int tipomaquina = gall.getTipogalleta().getMaquinasProceso().get(j);// prodmaq.getTipomaquina().getIdtipomaquina();

                int posmaq1 = 0;

                for (posmaq1 = 0; posmaq1 < gall.getTipogalleta().getMaquinasProceso().size(); posmaq1++) {
                    if (gall.getTipogalleta().getMaquinasProceso().get(posmaq1) == tipomaquina) {
                        break;// busco la posicion del tipo de mauqina en el arreglo de maquinas de la galleta
                    }
                }
                int cantidad = 0;
                if (gall.getDemanda_maq_cubierta()[posmaq1] < gall.getInv_ini_proc()[posmaq1]) {
                    cantidad = 0;
                } else {
                    cantidad = gall.getDemanda_maq_cubierta()[posmaq1] - gall.getInv_ini_proc()[posmaq1];
                }

                prosim.setCantProducida(cantidad * 30);
                merma = calcMermaTipoMaqTipoProd(tipomaquina, gall.getTipogalleta().getIdTipo(), solucion.getAsignados());
                prosim.setCantMerma(merma * 30);
                prosim.setProdReal(0);
                prosim.setMermaReal(0);
                s.guardarProdSim(prosim);
            }


        }
        return simulacion;


    }

    public Simulacion calcularSimulacion(Solucion solucion, Parametrosalgoritmo param, Date fecha) {

        Simulacion simulacion = new Simulacion(); // toy creando  el objeto de la tabla simulacion
        simulacion.setFechaHora(fecha);
        simulacion.setEstado(1);
        simulacion.setProduccion(solucion.calcProd());
        simulacion.setMerma(solucion.calcMerm());
        simulacion.setParametrosalgoritmo(param);
        simulacion.setCantnormal(solucion.getGalletas().get(0).getNumGalletasPedidas());//por 30 porque es al mes
        simulacion.setCantdecorada(solucion.getGalletas().get(1).getNumGalletasPedidas());
        simulacion.setCantrellena(solucion.getGalletas().get(2).getNumGalletasPedidas());
        simulacion.setTurno(solucion.getTurno());

        Simulacion simu = s.guardarSimulacion2(simulacion);
        //GUARDAR SIMULACION

        EmpleadoAlgoritmo emp = new EmpleadoAlgoritmo();
        Empleado empleado = new Empleado();
        Empleadoxmaquinasimulacion empmaqsi = new Empleadoxmaquinasimulacion();

        for (int i = 0; i < solucion.getAsignados().size(); i++) {


            empleado = buscarEmpleado(emp.getIdempleado());


            emp = solucion.getAsignados().get(i);
            empmaqsi.setEmpleado(empleado);
            empmaqsi.setMaquina(buscarMaquina(emp.getMaquina()));
            empmaqsi.setTipoproducto(s.getTipoProductoId(emp.getGalletaAsignada().getTipogalleta().getIdTipo()));
            empmaqsi.setSimulacion(simu);
            s.guardarEmpxmaqsimu(empmaqsi);
            //GUARDAR CADA UNO
        }
        Galleta gall = new Galleta();
        for (int i = 0; i < solucion.getGalletas().size(); i++) {

            gall = solucion.getGalletas().get(i);
            ArrayList<RecetaPfPi> receta = s.getIdTipoProductoIntermedio(gall.getTipogalleta().getIdTipo());

            for (int j = 0; j < gall.getTipogalleta().getMaquinasProceso().size(); j++) {
                int merma = 0;
                Productosimulacion prosim = new Productosimulacion();
                prosim.setTipoproducto(receta.get(j).getTipoproductoByIdtipoproductoPi());

                prosim.setSimulacion(simu);

                // Productoxmaquina prodmaq = s.getProductoxMaquina(receta.get(i).getTipoproductoByIdtipoproductoPi().getIdtipoproducto());//podriacambiarlo a que no sea por bd
                int tipomaquina = gall.getTipogalleta().getMaquinasProceso().get(j);// prodmaq.getTipomaquina().getIdtipomaquina();

                int posmaq1 = 0;

                for (posmaq1 = 0; posmaq1 < gall.getTipogalleta().getMaquinasProceso().size(); posmaq1++) {
                    if (gall.getTipogalleta().getMaquinasProceso().get(posmaq1) == tipomaquina) {
                        break;// busco la posicion del tipo de mauqina en el arreglo de maquinas de la galleta
                    }
                }

                prosim.setCantProducida(gall.getDemanda_maq_cubierta()[posmaq1]);
                merma = calcMermaTipoMaqTipoProd(tipomaquina, gall.getTipogalleta().getIdTipo(), solucion.getAsignados());
                prosim.setCantMerma(merma);
                s.guardarProdSim(prosim);
            }


        }

        return null;


    }

    public int calcMermaTipoMaqTipoProd(int tipomaq, int tipogalleta, ArrayList<EmpleadoAlgoritmo> empleados) {
        int merma = 0;
        for (int i = 0; i < empleados.size(); i++) {
            if (empleados.get(i).getTipoMaquinaAsignada() == tipomaq && empleados.get(i).getGalletaAsignada().getTipogalleta().getIdTipo() == tipogalleta) {

                merma = merma + empleados.get(i).getMermas()[tipomaq - 1];
            }
        }
        return merma;
    }

    public Maquina buscarMaquina(int id) {

        for (int i = 0; i < arregloMaquinas.size(); i++) {
            if (arregloMaquinas.get(i).getIdmaquina() == id) {
                return arregloMaquinas.get(i);
            }
        }

        return null;
    }

    public EmpleadoAlgoritmo copiarEmp(EmpleadoAlgoritmo emp) {
        EmpleadoAlgoritmo nuevo = new EmpleadoAlgoritmo();
        // Galleta nuevoGalleta;
        nuevo.setIdempleado(emp.getIdempleado());
        int[] prod = new int[4];
        int[] merm = new int[4];
        double[] efi = new double[4];

        // 
        for (int i = 0; i < emp.getCapacidad().length; i++) {
            prod[i] = emp.getProduccion()[i];
            merm[i] = emp.getMermas()[i];
            efi[i] = emp.getEficiencia()[i];
        }
        nuevo.setProduccion(prod);
        nuevo.setMermas(merm);
        //nuevo.setCapacidad(emp.getCapacidad());  
        nuevo.setEficiencia(efi);
        nuevo.setTipoMaquinaAsignada(emp.getTipoMaquinaAsignada());
        nuevo.setMaquina(emp.getMaquina());
        nuevo.calcularCap(nuevo.getProduccion(), nuevo.getMermas());
        nuevo.setTurno(emp.getTurno());
        //nuevoGalleta=copiarGalleta(emp.getGalletaAsignada());
        // nuevo.setGalletaAsignada(nuevoGalleta);

        return nuevo;
    }

    public void calculademanda(ArrayList<Pedidoproducto> pedidos, Demanda demanda1, Demanda demanda2, Demanda demanda3) {//muestra las demandas en la ventana
        ProduccionDAO p = new ProduccionDAO();
        int cant_normaltotal = 0;//calcula las demanandas spero no son guardadas aun
        int cant_dectotal = 0;
        int cant_reltotal = 0;

        ArrayList<Lineapedidoproducto> lineas = new ArrayList();

        for (int i = 0; i < pedidos.size(); i++) {
            lineas = p.getlineasByPedido(pedidos.get(i).getIdpedidoproducto());
            for (int j = 0; j < lineas.size(); j++) {
                switch (lineas.get(j).getTipoproducto().getIdtipoproducto()) {
                    case 1:
                        cant_normaltotal = cant_normaltotal + Math.round(lineas.get(j).getCantidad() * lineas.get(j).getPresentacion().getCantidad());
                        break;
                    case 2:
                        cant_dectotal = cant_dectotal + Math.round(lineas.get(j).getCantidad() * lineas.get(j).getPresentacion().getCantidad());
                        break;
                    case 3:
                        cant_reltotal = cant_reltotal + Math.round(lineas.get(j).getCantidad() * lineas.get(j).getPresentacion().getCantidad());
                }
            }
        }

        int cant_normal = cant_normaltotal / 3;

        int cant_dec = cant_dectotal / 3;

        int cant_rel = cant_reltotal / 3;

        demanda1.setCantPedNormal(cant_normal);
        demanda1.setCantPedDec(cant_dec);
        demanda1.setCantPedRell(cant_rel);
        demanda1.setTurno(1);

        demanda2.setCantPedNormal(cant_normal);
        demanda2.setCantPedDec(cant_dec);
        demanda2.setCantPedRell(cant_rel);
        demanda2.setTurno(2);

        demanda3.setCantPedNormal(cant_normal);
        demanda3.setCantPedDec(cant_dec);
        demanda3.setCantPedRell(cant_rel);
        demanda3.setTurno(3);

    }

    public void seleccionarsimulacion(Demanda dem, Simulacion simu) {// guarda la demanda con su simulacion, y pone las demas simualciones como no disponibles

        ProduccionDAO p = new ProduccionDAO();
        //if(dem.getCantPedDec()!=0 && dem.getCantPedNormal()!=0 && dem.getCantPedRell()!=0){
        dem.setSimulacion(simu);
        dem.setEstado(1);//en atencion
        simu.setEstado(1);
        RRHHDAO rdao = new RRHHDAO();

        ArrayList<Empleadoxmaquinasimulacion> listaemp = p.getEmplexMaq(simu.getIdsimulacion());
        // colocar en no dosiponilbes las maquinas y empleados.
        if (!listaemp.isEmpty()) {
            for (int i = 0; i < listaemp.size(); i++) {
                listaemp.get(i).getEmpleado().setEstado(0);
                listaemp.get(i).getMaquina().setEstado(1);
                rdao.guardarEmpleado(listaemp.get(i).getEmpleado());
                rdao.guardarMaquinaria(listaemp.get(i).getMaquina());
            }
        }
//            verificarSimulaciones(simu);
        //poner no disponibles las demas
        ArrayList<Simulacion> lista = p.getSimulacionesNoSeleccionadas(simu.getIdsimulacion(), dem.getTurno());
        if (!lista.isEmpty()) {

            for (int i = 0; i < lista.size(); i++) {

                lista.get(i).setEstado(2);//no disponible
                s.guardarSimulacion(lista.get(i));
            }
        }
        Date date = new Date();
        SimpleDateFormat dateformatfecha = new SimpleDateFormat("dd/MM/yyyy");
        //SimpleDateFormat dateformathora = new SimpleDateFormat("HH:mm:ss");
        Date datefecha = new Date();
        Date datehora = new Date();
        try {
            datefecha = dateformatfecha.parse(dateformatfecha.format(date));
            //datehora = dateformathora.parse(dateformathora.format(date));
        } catch (ParseException ex) {
        }
        dem.setFecha(datefecha);

        //falta poner el resto de simulacion que  tienen maqinas o empleados 
        s.guardarSimulacion(simu);
        p.guardarDemanda(dem);
        //      }
    }

    public void verificarSimulaciones(Simulacion simu) {
        ArrayList<Empleadoxmaquinasimulacion> lista = new ArrayList();
        ArrayList<Simulacion> listasimulacion = new ArrayList();

        int estado = 1;
        ProduccionDAO p = new ProduccionDAO();
        listasimulacion = p.listarSimulaciones(1);
        lista = p.getEmplexMaq(simu.getIdsimulacion());

        ArrayList<Empleadoxmaquinasimulacion> listaemp = new ArrayList();
        Empleadoxmaquinasimulacion empxmaq = new Empleadoxmaquinasimulacion();
        Simulacion simulacion = new Simulacion();
        if (!lista.isEmpty() && !listasimulacion.isEmpty()) {

            for (int k = 0; k < listasimulacion.size(); k++) {
                simulacion = listasimulacion.get(k);
                listaemp = p.getEmplexMaq(simulacion.getIdsimulacion());
                if (!listaemp.isEmpty()) {
                    for (int i = 0; i < lista.size(); i++) {
                        empxmaq = lista.get(i);
                        for (int j = 0; j < listaemp.size(); j++) {

                            if (empxmaq.getMaquina().getIdmaquina() == listaemp.get(j).getMaquina().getIdmaquina()) {
                                simulacion.setEstado(2);
                                s.guardarSimulacion(simulacion);
                                break;
                            }
                            if (empxmaq.getEmpleado().getIdempleado() == listaemp.get(j).getEmpleado().getIdempleado()) {
                                simulacion.setEstado(2);
                                s.guardarSimulacion(simulacion);
                                break;
                            }

                        }
                    }
                }
            }
        }
    }
}